if (!dojo._hasResource["dojo._base.lang"]) { //_hasResource checks added by build. Do not use _hasResource directly in your code.
    dojo._hasResource["dojo._base.lang"] = true;
    dojo.provide("dojo._base.lang");

    // Crockford (ish) functions

    dojo.isString = function(/*anything*/ it) {
        //	summary:
        //		Return true if it is a String
        return !!arguments.length && it != null && (typeof it == "string" || it instanceof String); // Boolean
    }

    dojo.isArray = function(/*anything*/ it) {
        //	summary:
        //		Return true if it is an Array
        return it && (it instanceof Array || typeof it == "array"); // Boolean
    }

    /*=====
     dojo.isFunction = function(it){
     // summary: Return true if it is a Function
     // it: anything
     //	return: Boolean
     }
     =====*/

    dojo.isFunction = (function() {
        var _isFunction = function(/*anything*/ it) {
            return it && (typeof it == "function" || it instanceof Function); // Boolean
        };

        return dojo.isSafari ?
            // only slow this down w/ gratuitious casting in Safari since it's what's b0rken
               function(/*anything*/ it) {
                   if (typeof it == "function" && it == "[object NodeList]") {
                       return false;
                   }
                   return _isFunction(it); // Boolean
               } : _isFunction;
    })();

    dojo.isObject = function(/*anything*/ it) {
        // summary:
        //		Returns true if it is a JavaScript object (or an Array, a Function
        //		or null)
        return it !== undefined &&
               (it === null || typeof it == "object" || dojo.isArray(it) || dojo.isFunction(it)); // Boolean
    }

    dojo.isArrayLike = function(/*anything*/ it) {
        //	summary:
        //		similar to dojo.isArray() but more permissive
        //	description:
        //		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
        //		a string or number and has a length property". Arguments objects
        //		and DOM collections will return true when passed to
        //		dojo.isArrayLike(), but will return false when passed to
        //		dojo.isArray().
        //	return:
        //		If it walks like a duck and quicks like a duck, return `true`
        var d = dojo;
        return it && it !== undefined &&
            // keep out built-in constructors (Number, String, ...) which have length
            // properties
               !d.isString(it) && !d.isFunction(it) &&
               !(it.tagName && it.tagName.toLowerCase() == 'form') &&
               (d.isArray(it) || isFinite(it.length)); // Boolean
    }

    dojo.isAlien = function(/*anything*/ it) {
        // summary:
        //		Returns true if it is a built-in function or some other kind of
        //		oddball that *should* report as a function but doesn't
        return it && !dojo.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
    }

    dojo.extend = function(/*Object*/ constructor, /*Object...*/ props) {
        // summary:
        //		Adds all properties and methods of props to constructor's
        //		prototype, making them available to all instances created with
        //		constructor.
        for (var i = 1, l = arguments.length; i < l; i++) {
            dojo._mixin(constructor.prototype, arguments[i]);
        }
        return constructor; // Object
    }

    dojo._hitchArgs = function(scope, method /*,...*/) {
        var pre = dojo._toArray(arguments, 2);
        var named = dojo.isString(method);
        return function() {
            // arrayify arguments
            var args = dojo._toArray(arguments);
            // locate our method
            var f = named ? (scope || dojo.global)[method] : method;
            // invoke with collected args
            return f && f.apply(scope || this, pre.concat(args)); // mixed
        } // Function
    }

    dojo.hitch = function(/*Object*/scope, /*Function|String*/method /*,...*/) {
        //	summary:
        //		Returns a function that will only ever execute in the a given scope.
        //		This allows for easy use of object member functions
        //		in callbacks and other places in which the "this" keyword may
        //		otherwise not reference the expected scope.
        //		Any number of default positional arguments may be passed as parameters
        //		beyond "method".
        //		Each of these values will be used to "placehold" (similar to curry)
        //		for the hitched function.
        //	scope:
        //		The scope to use when method executes. If method is a string,
        //		scope is also the object containing method.
        //	method:
        //		A function to be hitched to scope, or the name of the method in
        //		scope to be hitched.
        //	example:
        //	|	dojo.hitch(foo, "bar")();
        //		runs foo.bar() in the scope of foo
        //	example:
        //	|	dojo.hitch(foo, myFunction);
        //		returns a function that runs myFunction in the scope of foo
        if (arguments.length > 2) {
            return dojo._hitchArgs.apply(dojo, arguments); // Function
        }
        if (!method) {
            method = scope;
            scope = null;
        }
        if (dojo.isString(method)) {
            scope = scope || dojo.global;
            if (!scope[method]) {
                throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join(''));
            }
            return function() {
                return scope[method].apply(scope, arguments || []);
            }; // Function
        }
        return !scope ? method : function() {
            return method.apply(scope, arguments || []);
        }; // Function
    }

    /*=====
     dojo.delegate = function(obj, props){
     //	summary:
     //		returns a new object which "looks" to obj for properties which it
     //		does not have a value for. Optionally takes a bag of properties to
     //		seed the returned object with initially.
     //	description:
     //		This is a small implementaton of the Boodman/Crockford delegation
     //		pattern in JavaScript. An intermediate object constructor mediates
     //		the prototype chain for the returned object, using it to delegate
     //		down to obj for property lookup when object-local lookup fails.
     //		This can be thought of similarly to ES4's "wrap", save that it does
     //		not act on types but rather on pure objects.
     //	obj:
     //		The object to delegate to for properties not found directly on the
     //		return object or in props.
     //	props:
     //		an object containing properties to assign to the returned object
     //	returns:
     //		an Object of anonymous type
     //	example:
     //	|	var foo = { bar: "baz" };
     //	|	var thinger = dojo.delegate(foo, { thud: "xyzzy"});
     //	|	thinger.bar == "baz"; // delegated to foo
     //	|	foo.thud == undefined; // by definition
     //	|	thinger.thud == "xyzzy"; // mixed in from props
     //	|	foo.bar = "thonk";
     //	|	thinger.bar == "thonk"; // still delegated to foo's bar
     }
     =====*/


    dojo.delegate = dojo._delegate = function(obj, props) {

        // boodman/crockford delegation
        function TMP() {
        }
        ;
        TMP.prototype = obj;
        var tmp = new TMP();
        if (props) {
            dojo.mixin(tmp, props);
        }
        return tmp; // Object
    }

    dojo.partial = function(/*Function|String*/method /*, ...*/) {
        //	summary:
        //		similar to hitch() except that the scope object is left to be
        //		whatever the execution context eventually becomes.
        //	description:
        //		Calling dojo.partial is the functional equivalent of calling:
        //		|	dojo.hitch(null, funcName, ...);
        var arr = [ null ];
        return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function
    }

    dojo._toArray = function(/*Object*/obj, /*Number?*/offset, /*Array?*/ startWith) {
        //	summary:
        //		Converts an array-like object (i.e. arguments, DOMCollection) to an
        //		array. Returns a new Array with the elements of obj.
        //	obj:
        //		the object to "arrayify". We expect the object to have, at a
        //		minimum, a length property which corresponds to integer-indexed
        //		properties.
        //	offset:
        //		the location in obj to start iterating from. Defaults to 0.
        //		Optional.
        //	startWith:
        //		An array to pack with the properties of obj. If provided,
        //		properties in obj are appended at the end of startWith and
        //		startWith is the returned array.
        var arr = startWith || [];
        for (var x = offset || 0; x < obj.length; x++) {
            arr.push(obj[x]);
        }
        return arr; // Array
    }

    dojo.clone = function(/*anything*/ o) {
        // summary:
        //		Clones objects (including DOM nodes) and all children.
        //		Warning: do not clone cyclic structures.
        if (!o) {
            return o;
        }
        if (dojo.isArray(o)) {
            var r = [];
            for (var i = 0; i < o.length; ++i) {
                r.push(dojo.clone(o[i]));
            }
            return r; // Array
        }
        if (!dojo.isObject(o)) {
            return o;
            /*anything*/
        }
        if (o.nodeType && o.cloneNode) { // isNode
            return o.cloneNode(true); // Node
        }
        if (o instanceof Date) {
            return new Date(o.getTime());	// Date
        }
        // Generic objects
        var r = new o.constructor(); // specific to dojo.declare()'d classes!
        for (var i in o) {
            if (!(i in r) || r[i] != o[i]) {
                r[i] = dojo.clone(o[i]);
            }
        }
        return r; // Object
    }

    dojo.trim = function(/*String*/ str) {
        // summary:
        //		trims whitespaces from both sides of the string
        // description:
        //		This version of trim() was selected for inclusion into the base due
        //		to its compact size and relatively good performance (see Steven
        //		Levithan's blog:
        //		http://blog.stevenlevithan.com/archives/faster-trim-javascript).
        //		The fastest but longest version of this function is located at
        //		dojo.string.trim()
        return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');	// String
    }

}
